package com.zhoufeng;

import java.io.IOException;

import org.junit.Test;

import com.github.abel533.echarts.Option;
import com.github.abel533.echarts.axis.CategoryAxis;
import com.github.abel533.echarts.axis.ValueAxis;
import com.github.abel533.echarts.code.Magic;
import com.github.abel533.echarts.code.Tool;
import com.github.abel533.echarts.code.Trigger;
import com.github.abel533.echarts.feature.MagicType;
import com.github.abel533.echarts.series.Line;
import com.zjhbkj.xinfen.util.StringUtil;

public class Hello {
	public static void main(String[] args) throws IOException {

		// // 根据主机名来获取对应的InetAddress实例
		// InetAddress ip = InetAddress.getByName("122.112.65.143");
		// // 判断是否可达
		// System.out.println("oneedu是否可达：" + ip.isReachable(2000));
		// // 获取该InetAddress实例的IP字符串
		// System.out.println(ip.getHostAddress());
		// // 根据原始IP地址(字节数组形式)来获取对应的InetAddress实例
		// InetAddress local = InetAddress.getByName("122.112.65.143");
		// System.out.println("122.112.65.143是否可达：" + local.isReachable(5000));
		// InetAddress local1 = InetAddress.getByAddress(new byte[] { 127, 0, 0,
		// 1 });
		// System.out.println("本机是否可达：" + local1.isReachable(5000));
		// // 获取该InetAddress实例对应的全限定域名
		// System.out.println(local.getCanonicalHostName());

		// new Hello().testNegativeIntToHex();

		// Calendar calendar = Calendar.getInstance();
		//
		// calendar.setTime(new Date());
		//
		// calendar.add(Calendar.HOUR, -6);
		// System.out.println(calendar.getTimeInMillis());

		// DatagramSocket ds = new DatagramSocket(6060);

		// String send = "接收成功";
		// byte[] bsend = send.getBytes();
		// DatagramPacket pack = new DatagramPacket(bsend,bsend.length);
		//
		// ds.send(pack);
		
//		byte[] b = getCommand("40 DA FE 13 01 05 26 00 35 00 A0 02 5C 15 E9 82 25 FF FF BA 2C AB");
//		
//		System.out.println(b.length);
//		System.out.println(CommandUtil.bytesToHexString(b));
		
		
//		Integer i = 15;
//		
//		String s = Integer.toString(i,16).toUpperCase();
//		System.out.println(s);
		
		
//		System.out.println(new Date().getTime());
		
		
//		String s = "123";
//		
//		System.out.println(s.substring(1));
//		
//		
//		Timer timer = new Timer();
//		timer.schedule(new TimerTask() {
//			@Override
//			public void run() {
//				System.out.println("hello world!");
//			}
//		},new Date(), 1000);
		
		
		int count = Integer.parseInt("01",16);
		System.out.println(count);
		
//		String ss = "AA EA 03 3C 01 01 21 10 10 06 0F 13 0E 1E 14 00 64 F5 03 00 46 AB";
//		
//		String appmsg = new StringBuffer(ss).replace(18, 23, "%").replace(56, 58, "%").toString();
//		
//		System.out.println(appmsg);
	}

	public static byte[] getCommand(String command) {
		if (StringUtil.isNullOrEmpty(command)) {
			return new byte[] {};
		}
		try {
			String[] array = command.split(" +");
			byte[] commandArray = new byte[array.length];
			for (int i = 0; i < array.length; i++) {
				commandArray[i] = (byte) Integer.parseInt(array[i], 16);
			}
			return commandArray;
		} catch (Exception e) {
			return new byte[] {};
		}
	}

	@Test
	public void test() {
		// 地址:http://echarts.baidu.com/doc/example/line5.html
		Option option = new Option();
		option.legend("高度(km)与气温(°C)变化关系");

		option.toolbox().show(true).feature(Tool.mark, Tool.dataView, new MagicType(Magic.line, Magic.bar), Tool.restore, Tool.saveAsImage);

		option.calculable(true);
		option.tooltip().trigger(Trigger.axis).formatter("Temperature : <br/>{b}km : {c}°C");

		ValueAxis valueAxis = new ValueAxis();
		valueAxis.axisLabel().formatter("{value} °C");
		option.xAxis(valueAxis);

		CategoryAxis categoryAxis = new CategoryAxis();
		categoryAxis.axisLine().onZero(false);
		categoryAxis.axisLabel().formatter("{value} km");
		categoryAxis.boundaryGap(false);
		categoryAxis.data(0, 10, 20, 30, 40, 50, 60, 70, 80);
		option.yAxis(categoryAxis);

		Line line = new Line();
		line.smooth(true).name("高度(km)与气温(°C)变化关系").data(15, -50, -56.5, -46.5, -22.1, -2.5, -27.7, -55.7, -76.5).itemStyle().normal().lineStyle().shadowColor("rgba(0,0,0,0.4)");
		option.series(line);
//		option.exportToHtml("line5.html");
//		option.view();

	}

	public static void testPositiveIntToHex() {
		// 如果正数小于15时，只输入一位，而不是按我们想像的两位标准十六进制输出显示的，后面解决这个问题
		System.out.println(Integer.toHexString(2));// 2
		System.out.println(Integer.toHexString(15));// f
		System.out.println(Integer.toHexString(16));// 10
		System.out.println(Integer.valueOf("F", 16));// 16
	}

	/*
	 * Integer.valueOf()实质上调用的是Integer.parseInt()来完成的，所以
	 * Integer.parseInt()与Integer.valueOf()功能是一样的，只是返回值不 一样而已
	 */
	public void testNegativeIntToHex() {
		// 负整数时，前面输入了多余的 FF ，没有去掉前面多余的 FF，按并双字节形式输出
		System.out.println(Integer.toHexString(-2).toUpperCase());// FFFFFFFE

		// 实质上0xFF会像转换成0x000000FF后再进行位运算
		System.out.println(Integer.toHexString(-2 & 0xFF).toUpperCase());// FE
		System.out.println(Integer.toHexString(-2 & 0x000000FF).toUpperCase());// FE

		// 注，FE输出时不会为-2，因为此时不会把FE看成负数，valueOf会把所有数字串看成正的
		System.out.println(Integer.valueOf("FE", 16));// 254
		// 如果要输出-2，只能按以下形式输出
		System.out.println(Integer.valueOf("-2", 16));// -2

		// 所以要把 FE 看成负的话，只能在前面加上负号，但是这里输出还不是-2，
		// 而是先计算Integer.valueOf("FE", 16)，再在结果前加上负
		System.out.println(Integer.valueOf("-FE", 16));// -254

		/*
		 * 所以如果要输入某个负数，我们只能先求出该数的绝对值的原码十六进制，再在前面加上负号， 例如求表示-128，则先对绝对值128求十六进制
		 * 80，再在前面加上负号 -80
		 */
		System.out.println(Integer.valueOf("-80", 16));// -128

		/*
		 * 为什么说valueOf把所有数字串看成正的呢？请看下面三行代码，因为最大正数为2147483647， 如果再
		 * 在7fffffff基础上加上一个一，运行肯定会出错误（这与直接输出0x80000000不一样）， 那么就可以证明
		 */
		System.out.println(Integer.valueOf("7fffffff", 16));// 2147483647
		// 此句运行时会报错，因为最大正数为7fffffff，但如 -80000000 却又可以运行，因为没超出整数范围
		// System.out.println(Integer.valueOf("80000000", 16));//不能运行，已注掉
		System.out.println(Integer.valueOf("-80000000", 16));// -2147483648

		/*
		 * 注，输出时不是负数，而是正，因为0xFE只有8位，而整数是32位，所以以int形式出现时前 面会自动补24个零，第一位是零，所以最后是正数
		 */
		System.out.println(0xFE);// 254
		System.out.println(-0xFE);// -254
		// 但0x80000000已满，无需补，第一位为一，所以最后为负数
		System.out.println(0x80000000);// -2147483648
	}

	public void testNegativeIntToBin() {
		System.out.println(Integer.toBinaryString(-2));// 11111111111111111111111111111110
		// 实质上0xFF会像转换成0x000000FF后再进行位运算
		System.out.println(Integer.toBinaryString(-2 & 0xFF));// 11111110
		System.out.println(Integer.toBinaryString(-2 & 0x000000FF));// 11111110

		// 与上面十六进制是一样的
		System.out.println(Integer.valueOf("1111111111111111111111111111111", 2));// 2147483647
		// 下面语句运行会出错，已注掉
		// System.out.println(Integer.valueOf("10000000000000000000000000000000",
		// 2));
		System.out.println(Integer.valueOf("-10000000000000000000000000000000", 2));// -2147483648
		System.out.println(Integer.valueOf("11111110", 2));// 254
		System.out.println(Integer.valueOf("-11111110", 2));// -254

		/*
		 * 注，Java中没有直接使用二进制表示一个数（目前只支持八与十六进制直接表示法），下面其实是一个 八进制的数与十进制的数
		 */
		System.out.println(010);// 8
		System.out.println(10);// 10
	}

	public void testByteToHex() {

		byte negativeByte = -2;
		byte positiveByte = 2;

		/*
		 * toHexString方法类型为int型，所以转Hex前参数会提升成整型后再进行转换，过程如下：
		 * 10000010(原码)->11111110(补码)->11111111 11111111 11111111 11111110(提升)
		 * ->FFFFFFFE(转Hex进制输出)
		 */
		System.out.println(Integer.toHexString(negativeByte).toUpperCase());// FFFFFFFE

		/*
		 * 第一步把-2转成整型： 10000010(原码)->11111110(补码)->11111111 11111111 11111111
		 * 11111110(转整型) 第二步把 0xFF 前补24个零： 00000000 00000000 00000000 11111111
		 * 第三步：把第一二步结果进行与位运算： 00000000 00000000 00000000 11111110 最后一步：转十六进制结果为
		 * FE
		 */
		System.out.println(Integer.toHexString(negativeByte & 0xFF).toUpperCase());// FE

		// 另一种转换，可以针对负数与正数的byte都可以以完整的单字节输出
		System.out.println(Integer.toHexString((negativeByte & 0x000000ff) | 0xffffff00).substring(6).toUpperCase());// FE
		System.out.println(Integer.toHexString((positiveByte & 0x000000ff) | 0xffffff00).substring(6).toUpperCase());// 02
	}

	/**
	 * 位运算与算术运行中的类型提升机制是一样的
	 */
	public void testBiteMathematical() {
		System.out.println(0x8000000000000000L);// -9223372036854775808
		System.out.println((int) 0x8000000000000000L);// 0
		System.out.println(0x8000000000000010L);// -9223372036854775792
		System.out.println(0x80000000);// -2147483648
		System.out.println(0x80000010);// -2147483632

		// 0x00000010提升成长整型，最后结果为长整型0x8000000000000010L
		System.out.println(0x00000010 | 0x8000000000000000L);// -9223372036854775792
		// 0x0010提升成整形，最后结果为整型0x80000010
		System.out.println(0x0010 | 0x80000000);// -2147483632
	}
}
